<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
<title>XSLT and generateDS - Analysis, Comparison, and Evaluation</title>
<META NAME="description" CONTENT="XSLT and generateDS - Analysis, Comparison, and Evaluation">
<META NAME="keywords" CONTENT="xsltvsgenerateds">
<META NAME="resource-type" CONTENT="document">
<META NAME="distribution" CONTENT="global">
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="STYLESHEET" href="xsltvsgenerateds.css">
<link rel="first" href="xsltvsgenerateds.html">
<link rel="contents" href="contents.html" title="Contents">

</head>
<body>
<DIV CLASS="navigation">
<table align="center" width="100%" cellpadding="0" cellspacing="2">
<tr>
<td><img src="../icons/blank.gif"
  border="0" height="32"
  alt="" width="32"></td>
<td><img src="../icons/blank.gif"
  border="0" height="32"
  alt="" width="32"></td>
<td><img src="../icons/blank.gif"
  border="0" height="32"
  alt="" width="32"></td>
<td align="center" width="100%">XSLT and generateDS - Analysis, Comparison, and Evaluation</td>
<td><img src="../icons/blank.gif"
  border="0" height="32"
  alt="" width="32"></td>
<td><img src="../icons/blank.gif"
  border="0" height="32"
  alt="" width="32"></td>
</tr></table>
<br><hr>
</DIV>
<!--End of Navigation Panel-->

<P>

<div class="titlepage">
<center>
<h1>XSLT and generateDS - Analysis, Comparison, and Evaluation</h1>
<p><b><font size="+2">Dave Kuhlman</font></b></p>
<p>
	<a class="url" href="http://www.rexx.com/~dkuhlman">http://www.rexx.com/~dkuhlman</a> 
<BR>
Email: <span class="email">dkuhlman@rexx.com</span>
</p>
<p><strong>Aug 13, 2002</strong></p>
<p>
</center>
</div>

<P>

<H1><A NAME="SECTION001000000000000000000">
Front Matter</A>
</H1>

<P>

<H3>Abstract:</H3>
<DIV CLASS="ABSTRACT">

<P>

<P>
In this paper we consider and compare several technologies for
performing transformations on XML documents.  In particular we look
at the use of <b class="program">generateDS.py</b> to transform XML documents and
compare that use with <b class="program">XSLT</b>. 

<P>
</DIV>
<P>

<P>
<BR>
<BR><H2><A NAME="SECTION002000000000000000000">
Contents</A>
</H2>
<!--Table of Contents-->

<UL CLASS="TofC">
<LI><A href="xsltvsgenerateds.html">Front Matter</a>
<UL>
<LI><A href="#SECTION002100000000000000000">1 Introduction - What It Does</a>
<LI><A href="#SECTION002200000000000000000">2 Objective Comparisons</a>
<LI><A href="#SECTION002300000000000000000">3 Subjective Comparisons</a>
<UL>
<LI><A href="#SECTION002310000000000000000">3.1 Readability</a>
<LI><A href="#SECTION002320000000000000000">3.2 Declarative vs. Imperative</a>
<LI><A href="#SECTION002330000000000000000">3.3 Structure and Organization</a>
<LI><A href="#SECTION002340000000000000000">3.4 Development and Debugging</a>
</ul>
<LI><A href="#SECTION002400000000000000000">4 Evaluation</a>
</ul>
<LI><A href="#SECTION003000000000000000000">License, See also, Etc.</a>
<LI><A href="#SECTION004000000000000000000">About this document ...</a>
</ul>
<!--End of Table of Contents-->
<P>

<H1><A NAME="SECTION002100000000000000000">&nbsp;</A>
<BR>
1 Introduction - What It Does
</H1>

<P>
The problem space -- What are we trying to accomplish?  In this paper
we discuss technologies for performing transformations on XML documents,
that is, transformations where the source is an XML document and the
target (result) is any one of another XML document, an HTML or XHTML
document, a plain text file, a ``special'' text file (e.g. TeX/LaTeX),
etc.

<P>
In this paper, we pay special attention to the following technologies
(but also mention others):

<P>

<UL>
<LI><b class="program">XSLT</b> performs a transformation by using an
<b class="program">XSLT</b> engine and a stylesheet containing rules to transform
the element tree from one XML document into another element tree,
and then to generate a new document from that new element tree.

<P>
</LI>
<LI><b class="program">generateDS</b> generates Python classes that represent
the elements in an XML document.  These classes are generated from
an XML Schema which describes the XML documents to be processed.  In
addition, a parser is generated which, when executed, creates
instances of the classes from an XML document.  The classes can be
extended with methods that generate a new document.  Thus, the
generated parser and the extended classes can perform
transformations by parsing an XML document and generating a new
document.

<P>
</LI>
</UL>

<P>
<i>Caution</i> -- I'm a Python lover and advocate.  I'm biased
toward Python as a solution to problems.  I'm also the implementor
of <b class="program">generateDS.py</b>, so I'm likely to be partial towards it,
also.  In what follows, I've tried to present a balanced view, but
``let the reader beware''.

<P>
Principles:

<P>

<UL>
<LI>The use of <b class="program">generateDS.py</b> to perform transformations
is isomorphic to <b class="program">XSLT</b> up to coding style.  That is, they
can perform the same tasks, but use a different language and coding
style.  <b class="program">XSLT</b> uses template rules and a stylesheet.
<b class="program">generateDS.py</b> uses <b class="program">XSchema</b> for the definition of
input documents and uses Python to add the methods that generate a
new document.

<P>
</LI>
<LI><b class="program">generateDS.py</b> uses methods added to data
representation classes to perform a tree walk.

<P>
</LI>
<LI><b class="program">XSLT</b> uses (1) patterns to match XML elements, (2)
templates that specify the output to be generated for each pattern,
and (3) an engine that matches the patterns and generates the
output.

<P>
</LI>
</UL>

<P>
How to use <b class="program">XSLT</b>:

<P>

<UL>
<LI>Create a stylesheet file.  The stylesheet file contains the
template rules that guide the <b class="program">XSLT</b> engine.

<P>
</LI>
<LI>Create the templates (in the stylesheet file).  Each template
contains a pattern and an output template.  The <b class="program">XSLT</b>
engine applies the template if the pattern matches.  When the
pattern matches, the <b class="program">XSLT</b> engine uses the output template
to generate output.

<P>
</LI>
<LI>Execute the <b class="program">XSLT</b> engine, applying the <b class="program">XSLT</b>
stylesheet to the XML document to produce the output.

<P>
</LI>
</UL>

<P>
How to use <b class="program">generateDS.py</b> - (Details on this process are at
<a class="ulink" href="http://www.rexx.com/~dkuhlman/generateDS.html"
  >http://www.rexx.com/~dkuhlman/generateDS.html</a>.):

<P>

<UL>
<LI>Create an XML Schema definition of the input XML document type.

<P>
</LI>
<LI>Use <b class="program">generateDS.py</b> to generate the data representation classes
and the parser.  Optionally, generate subclasses of the data representation
classes.

<P>
</LI>
<LI>Add <I>export</I> methods to the generated classes (or
subclasses).  These methods will most likely perform a tree walk on
the data structures (classes) created by parsing the XML document.
And, these methods will generate output (hint: use <tt class="keyword">print</tt>
or call <tt class="method">write</tt> on an open file/stream.

<P>
</LI>
<LI>In the <I>main</I> function, call the <tt class="function">parse</tt> to parse the
XML document and create the document tree, then call the added
<I>export</I> method on the root object.

<P>
</LI>
</UL>

<P>

<H1><A NAME="SECTION002200000000000000000">&nbsp;</A>
<BR>
2 Objective Comparisons
</H1>

<P>
<table border align="center" style="border-collapse: collapse">
  <thead>
    <tr class="tableheader">
      <th align="left"><b>Feature</b>&nbsp;</th>
      <th align="left"><b>XSLT&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</b>&nbsp;</th>
      <th align="left"><b><b class="program">generateDS.py</b></b>&nbsp;</th>
      <th align="left"><b>YAML/PyYaml</b>&nbsp;</th>
      </tr>
    </thead>
  <tbody valign="baseline">
<P>

    <tr><td align="left" valign="baseline"><tt class="constant">Declarative</tt></td>
        <td align="left">Yes</td>
        <td align="left">No</td>
        <td align="left">No</td><P>

    <tr><td align="left" valign="baseline"><tt class="constant">Requires input definition</tt></td>
        <td align="left">No</td>
        <td align="left">Yes</td>
        <td align="left">No</td><P>

    <tr><td align="left" valign="baseline"><tt class="constant">Table/data driven</tt></td>
        <td align="left">Yes</td>
        <td align="left">No</td>
        <td align="left">No</td><P>

    <tr><td align="left" valign="baseline"><tt class="constant">Uses native data structures</tt></td>
        <td align="left">No</td>
        <td align="left">Yes</td>
        <td align="left">Yes</td><P>

    <tr><td align="left" valign="baseline"><tt class="constant">Standardized input</tt></td>
        <td align="left">Yes (XML)</td>
        <td align="left">Yes (XML)</td>
        <td align="left">Yes (YAML)</td><P>

    <tr><td align="left" valign="baseline"><tt class="constant">Full programming language</tt></td>
        <td align="left">No</td>
        <td align="left">Yes</td>
        <td align="left">Yes</td><P>

    <tr><td align="left" valign="baseline"><tt class="constant">Requires code generation</tt></td>
        <td align="left">No</td>
        <td align="left">Yes</td>
        <td align="left">No</td><P>

    <tr><td align="left" valign="baseline"><tt class="constant">Supports XML</tt></td>
        <td align="left">Yes</td>
        <td align="left">Yes</td>
        <td align="left">No</td><P>

    </tbody>
</table>

<P>
I have included YAML in this table for several reasons:

<P>

<UL>
<LI>I'm interested in YAML and in figuring out what to use it for
and how to use it.

<P>
</LI>
<LI>YAML can be thought of as an alternative representation
for structured data.  It is appropriate where and when strict
compatibility with XML is <i>not</i> a requirement.

<P>
</LI>
<LI>YAML loads YAML files to native data structures.  If Python is
used, the data structures are Python lists, dictionaries, etc

<P>
</LI>
<LI><b class="program">YAML</b> uses an indented format to store structured
data in files (and strings).  This format is cleaner and easier to
read and edit than the equivalent XML representation, claim 
YAML proponents.

<P>
</LI>
<LI>Transforming YAML to XML and XML to YAML is a straight forward
process and is relatively easy to implement, when an interchange
between YAML and XML is needed.  In fact, generating YAML files from
XML documents is an ideal task for <b class="program">generateDS.py</b>.

<P>
</LI>
<LI>There is a Python implementation of YAML.  You can find it at
<a class="ulink" href="http://www.yaml.org"
  >the YAML home page</a>

<P>
</LI>
</UL>

<P>
Explanation of features in the above table:

<P>

<UL>
<LI>Declarative -- Is input in the form of declarations or rules
rather than imperative, executable statements?  For example,
<b class="program">XSLT</b> uses XSL stylesheets and XSL template rules, whereas
<b class="program">generateDS.py</b> and <b class="program">PyYaml</b> use executable Python
code.

<P>
</LI>
<LI>Requires input definition -- Does processing require
definition of the structure of input files?  For example,
<b class="program">generateDS.py</b> requires an XSchema definition of the XML
input files to be processed.

<P>
</LI>
<LI>Uses native data structures -- Does processing use native
data structures in the supported programming language?  Example:
<b class="program">generateDS.py</b> uses instances of Python classes and Python
lists plus simple Python data types to represent the contents of an
XML file.  PyYaml uses Python lists and dictionaries plus simple
Python data types to represent the contents of a YAML file.

<P>
</LI>
<LI>Standardized input -- Is the format of data input described
in a publicly available standard?  What is that standard?

<P>
</LI>
<LI>Full programming language -- Does implementation of a
transformation use and make available a full programming language?
For example, <b class="program">generateDS.py</b> and PyYaml both employ Python.

<P>
</LI>
<LI>Requires code generation -- Does the system require the user
to generate code before use?  For example, <b class="program">generateDS.py</b>
requires the user/developer to generate Python code from an XSchema
definition of the input files.

<P>
</LI>
<LI>Supports XML -- Is XML supported?  For example,
<b class="program">XSLT</b> uses XML to define transformations (XML/XSL
stylesheets) and takes XML files as input.  And,
<b class="program">generateDS.py</b> uses XML (XSchema) to define the structure
of input files and takes XML as data input files.

<P>
</LI>
</UL>

<P>
Consequences:

<P>

<UL>
<LI>Support for XML -- Because <b class="program">XSLT</b> stylesheet are XML,
there is the possibility of using XML and XSL editors to develop
transformations (XSL stylesheets).

<P>
</LI>
<LI>Requires code generation -- Possibly a burden.  However, in
the case of <b class="program">generateDS.py</b>, the generated code for a
specific XML Schema definition can be reused to define multiple
transformations and the same document type.

<P>
</LI>
<LI>Uses native data structures -- Ability to use native data
structures of the programming language, is very helpful for
defining transformations on XML input.  This is especially true when
(1) the native data structures map reasonable directly to the
structures in the XML input document and (2) the native data
structures are reasonably high level.  For example, with
<b class="program">generateDS.py</b> there is a 1-to-1 correspondence between XML
elements and instances of Python classes.  And, elements in YAML
files map very directly onto Python lists and dictionaries.  Compare
this with the use of DOM, which also uses native (Python) data
structures, but requires laborious picking through children of
children of children etc in order to find information of interest
from an XML document.

<P>
</LI>
<LI>Full programming language -- ``XSLT was never intended as a
complete answer to the problem of transforming XML documents.''
Because <b class="program">XSLT</b> lacks a complete programming language, some
transformation tasks may be difficult or awkward.
<b class="program">generateDS.py</b>, which <i>does</i> provide access to a full
programming language, specifically Python, can be a more complete
solution and can more appropriately be applied to tasks that are
awkward for <b class="program">XSLT</b>.  However, note that while these tasks
<i>can</i> be solved with a full programming language, some will
require a more labor to do so.

<P>
</LI>
</UL>

<P>

<H1><A NAME="SECTION002300000000000000000">&nbsp;</A>
<BR>
3 Subjective Comparisons
</H1>

<P>
Here are some comparison points (we'll go into details later):

<P>

<UL>
<LI>The use of <b class="program">generateDS.py</b> is more readable for Python
programmers.  <b class="program">XSLT</b> is (possibly) more readable for those used to
reading XML.  (I don't really believe this.  However, it is
important to recognize that different programming languages and
styles will appeal to and be more understandable to different
users.)

<P>
</LI>
<LI><b class="program">XSLT</b> is declarative.  <b class="program">generateDS.py</b> is imperative
and object-oriented.

<P>
</LI>
<LI><b class="program">XSLT</b> uses multiple stylesheets to generate different
output from the same input XML document type.  <b class="program">generateDS.py</b>
can use multiple subclass modules with the same (super-)class module
to produce different styles of output.

<P>
</LI>
<LI><b class="program">XSLT</b> is most appropriate for producing ``text''
output, for example HTML, XML, and ``plain'' text.
<b class="program">generateDS.py</b> is suitable for producing these text formats
<i>and</i> other formats as well, for example, generating PDF,
inserting content into a relational database, updating a database or
repository, etc.  This is due to the fact that the export methods
added to the classes generated by <b class="program">generateDS.py</b> are
written in Python and can do most near anything that Python can do.

<P>
</LI>
<LI>Is development with <b class="program">XSLT</b> easy or hard?  Can
<b class="program">XSLT</b> stylesheets be debugged?

<P>
</LI>
</UL>

<P>

<H2><A NAME="SECTION002310000000000000000">
3.1 Readability</A>
</H2>

<P>
<b class="program">XSLT</b> is exceptionally verbose.  Your mileage may vary, but
even for those for who like to read XML, XSLT seems cluttered and
``dense''.  In contrast, Python, which is used to encode export
methods for is an exceptionally clear and readable language.  And,
the separation of representation classes from the classes that
contain the export functions helps to make the transformation and
generation process especially clear.

<P>
However, with respect to <b class="program">XSLT</b> the readability of XML and
XSLT stylesheets may be a red herring.  There are editors for XSLT
stylesheets which hide the actual XML and present a graphical (or
alternative) view of the stylesheet.  I do not have experience with
these tools, so I can't say how helpful they are.  Perhaps the best
that I can do is to say that if you intend to do serious work with
XSLT, you certainly should evaluate several of these tools.  I'm
guessing that there are some who would say that <b class="program">XSLT</b> is
not even intended to be edited directly and that it should
<i>only</i> be edited with an <b class="program">XSLT</b> editor.

<P>
Suggestion -- If you attempt to evaluate the readability of <b class="program">XSLT</b>
stylesheets, you may want to consider two dimensions to readability:

<P>

<UL>
<LI>Is the syntax transparent, i.e. can you perceive the intension of
a snippet of an <b class="program">XSLT</b> through the syntax?

<P>
</LI>
<LI>Is the logic transparent?  And, can you predict the behavior
of a stylesheet by reading the stylesheet?  Here are a few
additional and analogous questions: If you make a change to a
stylesheet in one location, does it cause changes in the behavior of
other parts of the stylesheet?  In other words, do changes have
objectionable non-local effects?

<P>
</LI>
</UL>

<P>

<H2><A NAME="SECTION002320000000000000000">
3.2 Declarative vs. Imperative</A>
</H2>

<P>
Since <b class="program">XSLT</b> is declarative, the logic is in a separate program,
the <b class="program">XSLT</b> engine.

<P>
Since <b class="program">generateDS.py</b> is imperative all control logic is
explicit and visible in the added export methods.  For example, an
export method in a parent node (XML element) explicitly calls the
export methods in child nodes.

<P>
For Pythonistas, ``Explicit is better than implicit.'' (See
<a class="ulink" href="http://www.python.org/doc/Humor.html#zen"
  >The Zen of Python (by Tim Peters)</a>.)  If you also feel this
way, the fact that the logic of XSLT processing is in some sense
hidden in the XSLT engine may be a negative for you.  Although an
XSLT editor may make the stylesheet more readable, controlling the
logic of an XSLT engine may remain somewhat mysterious.

<P>

<H2><A NAME="SECTION002330000000000000000">
3.3 Structure and Organization</A>
</H2>

<P>
In <b class="program">XSLT</b>, input processing (pattern matching) is mixed with
output generation.  Each template rule contains both a pattern and
an output template.  In <b class="program">generateDS.py</b> input processing and
output generation can be separated.  With <b class="program">generateDS.py</b>,
subclasses can be generated in a separate file (from the
superclasses), so that the output processing (the export methods,
which are added to the subclasses) can be in a separate file from
the data representation and parsing classes.

<P>
Some user/developers will prefer the unification or encapsulation of
the pattern matching code with the output generation code that
<b class="program">XSLT</b> provides.  Others will prefer the ability to organize
their code in a way that separates or localizes output generation
code from the parsing (recognizing) code.  <b class="program">generateDS.py</b>
provides this separation.

<P>
The template rules in an <b class="program">XSLT</b> stylesheet form an
unordered collection.  The export methods used in
<b class="program">generateDS.py</b> are organized in classes that follow the
hierarchical structure of the XML document type.  However, the
classes can be organized as an unordered collection.  In practice,
<b class="program">generateDS.py</b> generates the classes (roughly) in order
from top to bottom.

<P>
One thing to realize is that in declarative and rule-based
systems(of which <b class="program">XSLT</b> is an example), the addition of one
(or more) rules to an existing system can change the behavior of
that system in ways that are difficult to predict.  The same thing
can be said of changes made to the logic (executable code) in an
imperative system (e.g. <b class="program">generateDS.py</b>).  It is a
subjective judgment as to which (changes to a rule-based system or
changes to an imperative system) are more difficult to manage,
predict, etc.

<P>

<H2><A NAME="SECTION002340000000000000000">
3.4 Development and Debugging</A>
</H2>

<P>
I'm going to have to leave
these questions to those who have more experience with
<b class="program">XSLT</b>.  

<P>
However, for those of you who seek to evaluate this aspect of
<b class="program">XSLT</b>, here are a few questions you may want to ask:

<P>

<UL>
<LI>Do useful debugging tools and techniques exist for
<b class="program">XSLT</b>?

<P>
</LI>
<LI>Is it possible to trace the evaluation of an XML document
under an <b class="program">XSLT</b> stylesheet?

<P>
</LI>
<LI>Can a developer produce a listing of the template rules
attempted and selected and the XML elements evaluated as rules are
selected?

<P>
</LI>
</UL>

<P>
With respect to transformations implemented with
<b class="program">generateDS.py</b>, available debugging techniques are those
available for debugging any Python code, e.g. <b class="program">pdb</b> (the
Python debugger) or another Python debugger if you have one,
<tt class="keyword">print</tt> statements, etc.

<P>

<H1><A NAME="SECTION002400000000000000000">&nbsp;</A>
<BR>
4 Evaluation
</H1>

<P>
In this section, we try to offer some guidance about when to use
each of these two technologies and what to use each for.

<P>
If you already know <b class="program">XSLT</b> and have experience with it and
especially if you do not know Python, lean toward <b class="program">XSLT</b>.
If you already know Python and do not know <b class="program">XSLT</b>, lean toward
<b class="program">generateDS.py</b>.

<P>
If you need to generate HTML, XML, or plain text, then
<b class="program">XSLT</b> seems appropriate.  <b class="program">generateDS.py</b> is
appropriate for these output types, but also for generating PDF
(e.g. using the ReportLab library), for updating relational (and
other) databases, etc.  Note that if you have a need to generate PDF
from XML, you should also look at the ReportLab RML2PDF package.
It's proprietary and a bit expensive.  However, from my quick
reading at ReportLab's Web site, it looks very powerful and quite
well thought out.  See <a class="ulink" href="http://www.reportlab.com/rml/index.html"
  >RML2PDF: the XML Based Reporting
Solution</a>.

<P>
Additional suggestions on when and where to use
<b class="program">generateDS.py</b>:

<P>

<UL>
<LI>Transformations to structured text files: XML to HTML; XML to
XML; XML to text.

<P>
</LI>
<LI>Transformations to other formats: XML to PDF (but look at the
ReportLab RML2PDF package, too); XML to database; etc.

<P>
</LI>
<LI>Analysis of XML documents -- Sometimes the process of generating
output requires analysis and search of the source (XML) document.
<b class="program">generateDS.py</b> is especially appropriate when complex
analysis, searching, and testing is required.

<P>
</LI>
</UL>

<P>
It is claimed that <b class="program">XSLT</b> is not a
solution to all (transformation) problems and, for that, a full
programming language is needed.  <b class="program">generateDS.py</b> can be
viewed as an attempt to make the alternative more usable.
<b class="program">generateDS.py</b> provides the parser and data structures that
make it easier to write transformations on XML easier.

<P>
One approach or view -- Use a full programming language for
business logic; use <b class="program">XSLT</b> for styling and formatting
(e.g. to generate HTML).  Here are several approaches for doing so:

<P>

<UL>
<LI>Use business logic in a full programming language to produce
XML documents.  Then use <b class="program">XSLT</b> to transform those documents
into a viewable format, e.g. HTML.

<P>
</LI>
<LI>Use business logic in a full programming language to directly
produce a viewable format, e.g. HTML.

<P>
</LI>
<LI>Use <b class="program">generateDS.py</b> to transform XML to XML.  Then use
<b class="program">XSLT</b> to transform the resulting XML documents into a
viewable format, e.g. HTML.

<P>
</LI>
<LI>You could even generate XML documents of a generic type from
YAML files, then use <b class="program">generateDS.py</b> to implement
transformations from that common XML document type to a variety of
XML document types, and finally use <b class="program">XSLT</b> to transform
those XML documents to a viewable format.

<P>
</LI>
</UL>

<P>
As you can see, if you put all these tools in your toolkit, you have
a lot of options.

<P>

<H1><A NAME="SECTION003000000000000000000">&nbsp;</A>
<BR>
License, See also, Etc.
</H1>

<P>
<DIV CLASS="centerline" ID="par612" ALIGN="CENTER">
<b>Copyright (c) 2002 Dave Kuhlman</b></DIV>

<P>
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

<P>
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

<P>
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

<P>
<div class="seealso">
  <p class="heading"><b>See Also:</b></p>

<P>
<dl compact class="seetitle">
    <dt><em class="citetitle"><a href="http://www.rexx.com/~dkuhlman/"
        >Dave's Web Site</a></em>
    <dd>for more software and information on using Python for XML and the Web
  </dl>

<P>
<dl compact class="seetitle">
    <dt><em class="citetitle"><a href="http://www.python.org/"
        >The main Python Web Site</a></em>
    <dd>for more information on Python
  </dl>

<P>
<dl compact class="seetitle">
    <dt><em class="citetitle"><a href="http://www.python.org/sigs/xml-sig/"
        >The Python XML Special Interest Group</a></em>
    <dd>for more information on processing XML with Python
  </dl>

<P>
<dl compact class="seetitle">
    <dt><em class="citetitle"><a href="http://www.reportlab.com"
        >ReportLab</a></em>
    <dd>for more information on the ReportLab library and RML2PDF
for generating PDF documents
  </dl>

<P>
<dl compact class="seetitle">
    <dt><em class="citetitle"><a href="http://xmlsoft.org/XSLT.html"
        >The XML C library for Gnome -- XSLT</a></em>
    <dd>for more information on the Xmlsoft XSLT library
(along with its Python interface)
  </dl>

<P>
<dl compact class="seetitle">
    <dt><em class="citetitle"><a href="http://www.xml.com/pub/a/1999/05/xsl/xslconsidered_1.html"
        >XSL Considered Harmful, by Michael Leventhal</a></em>
    <dd>for an article critical of XSL
  </dl>

<P>
<dl compact class="seetitle">
    <dt><em class="citetitle"><a href="http://www.yaml.org/"
        >The YAML home page</a></em>
    <dd>for more information on YAML (and PyYaml)
  </dl>

<P>
</div>

<P>

<H1><A NAME="SECTION004000000000000000000">
About this document ...</A>
</H1>
 <strong>XSLT and generateDS - Analysis, Comparison, and Evaluation</strong>,
Aug 13, 2002
<p> This document was generated using the <a
    href="http://saftsack.fs.uni-bayreuth.de/~latex2ht/">
    <strong>LaTeX</strong>2<tt>HTML</tt></a> translator.
</p>

<p> <a
    href="http://saftsack.fs.uni-bayreuth.de/~latex2ht/">
    <strong>LaTeX</strong>2<tt>HTML</tt></a> is Copyright &copy;
  1993, 1994, 1995, 1996, 1997, <a
    href="http://cbl.leeds.ac.uk/nikos/personal.html">Nikos
    Drakos</a>, Computer Based Learning Unit, University of
  Leeds, and Copyright &copy; 1997, 1998, <a
    href="http://www.maths.mq.edu.au/~ross/">Ross
    Moore</a>, Mathematics Department, Macquarie University,
  Sydney.
</p>

<p> The application of <a
    href="http://saftsack.fs.uni-bayreuth.de/~latex2ht/">
    <strong>LaTeX</strong>2<tt>HTML</tt></a> to the Python
  documentation has been heavily tailored by Fred L. Drake,
  Jr.  Original navigation icons were contributed by Christopher
  Petrilli.
</p>

<DIV CLASS="navigation">
<p><hr>
<table align="center" width="100%" cellpadding="0" cellspacing="2">
<tr>
<td><img src="../icons/blank.gif"
  border="0" height="32"
  alt="" width="32"></td>
<td><img src="../icons/blank.gif"
  border="0" height="32"
  alt="" width="32"></td>
<td><img src="../icons/blank.gif"
  border="0" height="32"
  alt="" width="32"></td>
<td align="center" width="100%">XSLT and generateDS - Analysis, Comparison, and Evaluation</td>
<td><img src="../icons/blank.gif"
  border="0" height="32"
  alt="" width="32"></td>
<td><img src="../icons/blank.gif"
  border="0" height="32"
  alt="" width="32"></td>
</tr></table>
<hr>
<span class="release-info">Documentation released on Aug 13, 2002.</span>
</DIV>
<!--End of Navigation Panel-->

</BODY>
</HTML>
